#include<iostream>
using namespace std;


class A
{
public:
	A(int a=0 , int b=0 )
	{
		_a = a;
		_b = b;
		cout << "A():" << this << endl;
	}
	A(const A& a)
	{
		_a = a._a;
		_b = a._b;
		cout << "A(const A& a):" << this << endl;
	}
	~A()
	{
		_a = 0;
		_b = 0;
		cout << "~A():" << this << endl;
	}
private:
	int _a;
	int _b;
};

int main()
{
	//原则：free和malloc匹配，delete和new匹配

	////自定义类型的new和delete-->stack类
	//new：先开空间（operator new->malloc) 再调用构造函数
	//delete：先调用析构函数（清理资源） 再释放空间（operator delete->free->_free_dbg）

	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1, 1);   //调用构造函数和析构函数 优化掉拷贝构造函数
	free(p1);
	delete p2;

	int* p3 = (int*)malloc(sizeof(int));  //不支持初始化
	int* p4 = new int(1);   //支持初始化
	free(p3);
	delete p4;

	int* p5 = (int*)malloc(sizeof(int) * 10);
	free(p5);
	int* p6 = new int[10];  //不初始化
	delete[] p6;
	int* p7 = new int[10] {1, 2, 3, 4, 5};  //也支持初始化
	delete[] p7;

	//A* p8 = new A[4]{ A(1,1),A(2,2)};  //有默认构造函数会自动调用构造函数进行初始化，可以不传或不传满4个对象
	A* p9 = new A[4]{ A(1,2),A(1,3),A(1,4),A(1,5) };  //没有默认构造函数必需传满4个对象
	delete[] p9;

	//捕获异常
	/*try
	{
		int* p10 = nullptr;
		do
		{
			p10 = new int[1024 * 1024];
			cout << p10 << endl;
		} while (p10);
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}*/

	//定位new表达式
	A* p11 = (A*)malloc(sizeof(A));   //p1指向一块开辟好的空间，不是一个对象，不能自动调用构造函数和析构函数
	
	//显示调用构造函数
	new(p11)A(10, 20);
	//显示调用析构函数
	p11->~A();
	free(p11);

	//char* p12 = new char[1024 * 1024 * 1024];
	//cout << p12 << endl;  //死循环打印随机值 p12没有初始化  找不到结束标志\0

	char* p12 = new char[1024 * 1024 * 1024] {'a', 'b', 'c', '\0'};
	cout << p12 << endl;  //死循环打印随机值 p12没有初始化  找不到结束标志\0

	return 0;

}